AOL File Library: 2,801 to 2,900/aol-file-protocol-4400-2801-to-2900.zip/AOLDLs/C++ Files Library/SK (Sockects) 1.4.1 r2/SK v1.4.1 r2.sit/SK 1.4.1 r2/SK/SK Sources/SK_Dispatch.cc

C/C++ Source or Header | 1994-06-13 | 53KB | 2,421 lines

/***************************************************************************
*
*
* Copyright ⌐ 1992-1994 Matthias Neeracher and the Decision Systems Group
*
* Permission is granted to anyone to use this software for any purpose on
* any computer system, and to redistribute it freely, subject to the
* following restrictions:
*
* 1) The authors and the Decision Systems Group are not responsible for
*    the direct or indirect consequences of use of this software, no matter
*    how awful, even if they arise from defects in the software itself.
*    This restriction applies to the use of this and any derived source code
*    and also to the use of all binary produced from this and any derived
*    source code.
* 2) The origin and copyrights of this software must not be misrepresented,
*    either by explicit claim or by omission or alteration of copyright or
*    authorship header information in this file or in any derived file.
* 3) Altered or derived versions must be plainly marked as such, and must not
*    be misrepresented as being the original software.
*
* We encourage users of this software to provide feedback, bug fixes,
* and enhancements to the authors for incorporation into future releases.
*
* ==========================================================================
*
* FILE: SK_Dispatch.cc
*
* AUTHOR: Matthias Neeracher and Stephan Deibel
*
* CREATION DATE: 24Mar92
*
* VERSION: 13Jun94
*
* DESCRIPTION:
*
* Dispatch routines for C calls to C++ objects
*
* NOTES:
*
* 0) This code was derived from Matthias Neerarcher's GUSI 1.1.0; Copyrights
*    are subject to that fact.
*
* MODIFICATIONS:
* --------------------------------------------------------------------------
* Date     Name      Description of modification
* --------------------------------------------------------------------------
*
* 31Mar92    MN       unix domain socket calls
* 16Apr92    MN       User interrupt stuff
* 17Apr92    MN       Spin routines
* 18Apr92    MN       Changed read/write/send/recv dispatchers
* 19Apr92    MN       C++ Rewrite
* 06Jun92    MN       CSK_Feature
* 27Jun92    MN       choose(), SKg_NewSF
* 13Jul92    MN       SKg_ProcessMgr
* 30Jul92    MN       Features with initializers
* 03Aug92    MN       Move Scatter/Gather to SK_Buffer.cc
* 05Aug92    MN       Change the way standard I/O channels are opened
* 30Aug92    MN       Move SKg_PPC to SK_PPC.cp, AppleTalkIdentity
* 12Sep92    MN       SK_getdtablesize()
* 05Oct92    MN       Small fix in event dispatching
* 25Nov92    MN       Still trying to get standard descriptors for standalone programs right. sigh.
* 03Jan93    MN       CSK_Configuration
* 17Jan93    MN       Be more careful about user aborts.
* 31Jan93    MN       Introducing daemons (pleased to meet you, hope you guess my name)
* 13Jul93    SD       Port to THINK C++ 6.0
* 21Jul93    SD       Subsetted to only TCP/UDP, applied DSG naming
*                    conventions and commenting guidelines, and
*                    changed name to "SK" for clear distinction from
*                    the GUSI code from which this was derived
* 13Jun94   SD       Updated based on relevant changes to GUSI (through 1.4.1)
*
*/

#include <stdio.h>
#include "SK_P.hh"
#include "SetJmp.h"
#include "Signal.h"
// #include "CursorCtl.h"
#include "Resources.h"
#include "Events.h"
#include "Windows.h"
#include "Desk.h"
#include "Script.h"
#include "OSEvents.h"
#include "Traps.h"
#include "CommResources.h"
#include "CTBUtilities.h"
#include "Connections.h"
#include "FileTransfers.h"
#include "Terminals.h"
#include "EPPC.h"
#include <AppleEvents.h>

// Extra "extern"s
extern "C" int file_open(const char * name, int flags);
extern Boolean IsDevice(const char * fn);

// If STANDALONE is not defined anywhere, then we assume that this is a daemon
// server program
#ifndef STANDALONE
#define STANDALONE FALSE
#endif

/**************************************************************************/
/**************************************************************************/
/* Globals */

// SK configuration object and table of active sockets
// IMPORTANT NOTE: Changing the order of these two globals will prevent proper initialization!
// NOTE ALSO: The SKg_Config variable SHOULD be 'const' but adding this under Symantec C++ 7.0
//    results in a link error (undefined).
CSK_Configuration SKg_Config;
CSK_SocketTable SKg_SocketTable;

// SK spin routine for handling idle time during waits on sockets
SKt_SpinFn SKg_SpinRoutine = &SK_DefaultSpinRoutine;

// SK event handler used by idle time spin routine
static SKt_EvtHandler *SKg_EventHandler = NULL;

// Event mask used by SK event handler
static short SKg_EvtMask = 0;

// ???
static int SKg_ErrorSock = -1;
static int SKg_ErrorType = 0;
static int SKg_ErrorCount = 0;
const int SKg_ErrorMax = 3;

// Feature availability globals.

CSK_Feature SKg_MakeFSSpec(
                gestaltFSAttr,
                (1<<gestaltHasFSSpecCalls),
                (1<<gestaltHasFSSpecCalls));
CSK_Feature SKg_Alias(
                gestaltAliasMgrAttr,
                (1<<gestaltAliasMgrPresent),
                (1<<gestaltAliasMgrPresent));
CSK_Feature    SKg_WNE((short) _WaitNextEvent, (TrapType) ToolTrap);
CSK_Feature    SKg_NewSF(
                gestaltStandardFileAttr,
                (1<<gestaltStandardFile58),
                (1<<gestaltStandardFile58));
CSK_Feature SKg_ProcessMgr(
                gestaltOSAttr,
                (1<<gestaltLaunchControl),
                (1<<gestaltLaunchControl));
CSK_Feature SKg_CRM_P(
                gestaltCRMAttr,
                (1<<gestaltCRMPresent),
                (1<<gestaltCRMPresent));
CSK_Feature SKg_CRM(SKg_CRM_P, InitCRM);
CSK_Feature SKg_CTB(SKg_CRM, InitCTBUtilities);
CSK_Feature SKg_StdNBP_P(
                gestaltStdNBPAttr,
                (1<<gestaltStdNBPPresent),
                (1<<gestaltStdNBPPresent));
CSK_Feature SKg_StdNBP(SKg_CTB, SKg_StdNBP_P);
CSK_Feature SKg_CM(SKg_CTB, InitCM);
CSK_Feature SKg_FT(SKg_CTB, InitFT);
CSK_Feature SKg_TM(SKg_CTB, InitTM);
CSK_Feature SKg_AppleEvents(
                gestaltAppleEventsAttr,
                (1<<gestaltAppleEventsPresent),
                (1<<gestaltAppleEventsPresent));
CSK_Feature SKg_RevisedTimeMgr(
                gestaltTimeMgrVersion,
                2L);



/**************************************************************************/
/**************************************************************************/
/* Implementation of external sockets interface routines -- These act as
*  the "glue" between the straight "C" calling interface and the C++
*  internals of this package
*/


/*************************************************************************** *
* FUNCTION:
*
* SK_getdtablesize
*
* DESCRIPTION:
*
* Return the maximum number of file descriptors -- the size of any descriptor
* table in this package.
*
* RETURNS:
*
* int            -- The max number of file descriptors
*
*/

int SK_getdtablesize()
{
    return SKk_MaxFD;
}


/*************************************************************************** *
* FUNCTION:
*
* SK_socket
*
* DESCRIPTION:
*
* Allocate a socket of given domain, type, and protocol
*
* PARAMETERS:
*
* int            -- The domain for new socket
* int            -- The type of new socket
* short            -- The protocol for new socket
*
* RETURNS:
*
* int            -- The file descriptor for the new socket, or -1 upon failure
*
*/

int SK_socket(int domain, int type, int protocol)
{
    CSK_SocketDomain * dom;
    CSK_Socket * sock;
    int    fd;

    dom = CSK_SocketDomain::Domain(domain);
    if (dom != NULL)
        sock = dom->socket(type, protocol);
        if (sock != NULL)
            if ((fd = SKg_SocketTable.Install(sock)) != -1)
                return fd;
            else
                delete sock;

    return -1;
}


/*************************************************************************** *
* FUNCTION:
*
* SK_bind
*
* DESCRIPTION:
*
* Bind the given socket to the given internet host name
*
* PARAMETERS:
*
* int                            -- The socket file descriptor
* const struct sockaddr *        -- Pointer to internet address name
* int                            -- Length of name (null terminator is NOT used)
*
* RETURNS:
*
* If the binding succeeds, then 0 is returned. Otherwise a -1 is returned,
* and a more specific error code is stored in errno (see appropriate socket
* type for details).
*
*/

int SK_bind(int s, const struct sockaddr *name, int namelen)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->bind((void *) name, namelen) : -1;
}


/*************************************************************************** *
* FUNCTION:
*
* SK_connect
*
* DESCRIPTION:
*
* Connect the given socket to the given internet address (ip number)
*
* PARAMETERS:
*
* int                            -- The socket file descriptor
* const struct sockaddr *        -- The internet address
* int                            -- The length of the internet address
*
* RETURNS:
*
* If the connection succeeds, then 0 is returned. Otherwise a -1 is returned,
* and a more specific error code is stored in errno (see appropriate socket
* type for details).
*
*/

int SK_connect(int s, const struct sockaddr *addr, int addrlen)
{
    CSK_Socket *sock = SKg_SocketTable[s];
    return sock ? sock->connect((void *) addr, addrlen) : -1;
}


/*************************************************************************** *
* FUNCTION:
*
* SK_listen
*
* DESCRIPTION:
*
* Listen on the given socket
*
* PARAMETERS:
*
* int            -- The socket file descriptor
* int            -- unused
*
* RETURNS:
*
* If listening succeeds, then 0 is returned. Otherwise a -1 is returned,
* and a more specific error code is stored in errno (see appropriate
* socket type for details).
*
*/

int SK_listen(int s, int qlen)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->listen(qlen) : -1;
}


/*************************************************************************** *
* FUNCTION:
*
* SK_accept
*
* DESCRIPTION:
*
* Accept a connection request on the given socket
*
* PARAMETERS:
*
* int                    -- The socket file descriptor
* struct sockaddr *     -- Pointer to memory for address return value
* int *                    -- Pointer to memory for return value (initialized
*                           to space available in address return buffer)
*
* RETURNS:
*
* int                    -- The socket file descriptor of the new socket created
*                           to handle the newly established connection.  The old
*                           socket is kept active so that additional connections
*                          can be made to it by other clients.
* struct sockaddr *     -- 2nd parameter: The internet number connection was made from
* int *                    -- 3rd parameter: Length of above internet address
*
*/

int SK_accept(int s, struct sockaddr *addr, int *addrlen)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    if (sock != NULL)
        sock = sock->accept(addr, addrlen);
        if (sock != NULL)
            if ((s = SKg_SocketTable.Install(sock)) != -1)
                return s;
            else
                delete sock;

    return -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_close
*
* DESCRIPTION:
*
* Close connection on given socket
*
* PARAMETERS:
*
* int            -- The socket file descriptor
*
* RETURNS:
*
* int             -- Error value (0 = no error)
*
*/

int SK_close(int s)
{
    SKg_ErrorSock = -1;

    return SKg_SocketTable.Remove(s);
}


/****************************************************************************
* FUNCTION:
*
* SK_read
*
* DESCRIPTION:
*
* Read bytes from the given socket using a plain buffer.
*
* PARAMETERS:
*
* int            -- The socket file descriptor
* char *        -- Pointer to buffer memory
* unsigned        -- Length of available buffer memory
*
* RETURNS:
*
* Bytes read are returned in the given buffer memory.  The integer
* function return value is the number of bytes actually received (-1 = error).
*
*/

int SK_read(int s, char *buffer, unsigned buflen)
{
    SKg_Config.DoAutoSpin();

    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->read(buffer, buflen) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_readv
*
* DESCRIPTION:
*
* Read bytes from the given socket using a BSD Unix iovec structure.
*
* PARAMETERS:
*
* int                    -- The socket file descriptor
* const struct iovec *    -- Pointer to buffer memory
* unsigned                -- Length of available buffer memory
*
* RETURNS:
*
* Bytes read are returned in the given iovec structure.  The integer
* function return value is the number of bytes actually received (-1 = error).
*
*/

int SK_readv(int s, const struct iovec *iov, int count)
{
    SKg_Config.DoAutoSpin();

    CSK_Socket *sock = SKg_SocketTable[s];

    if (sock)    {
        CSK_Scatterer scatt(iov, count);

        if (scatt)
            return scatt.GetLength(sock->read(scatt.GetBuffer(), scatt.GetBufferLength()));
        else
            return SK_Error(ENOMEM);
    } else
        return -1;
}

/****************************************************************************
* FUNCTION:
*
* SK_recv
*
* DESCRIPTION:
*
* Read bytes from the given socket using a plain buffer.
*
* This is equivalent to SK_read(), except that this function is used
* when conceptually a whole message is being received [SK_read() is
* used when bytes are read from an ongoing stream].
*
* PARAMETERS:
*
* int                -- The socket file descriptor
* void *            -- Pointer to buffer memory
* unsigned            -- Length of available buffer memory
* int                -- Unused
*
* RETURNS:
*
* Bytes read are returned in the given buffer memory.  The integer
* function return value is the number of bytes actually received (-1 = error).
*
*/

int SK_recv(int s, void *buffer, int buflen, int flags)
{
    SKg_Config.DoAutoSpin();

    int fromlen = 0;
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->recvfrom(buffer, buflen, flags, nil, &fromlen) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_recvfrom
*
* DESCRIPTION:
*
* Read bytes from the given socket using a plain buffer and fetch internet
* address of sender of bytes.
*
* PARAMETERS:
*
* int                -- The socket file descriptor
* void *            -- Pointer to buffer memory
* unsigned            -- Length of available buffer memory
* int                -- Unused
* struct sockaddr *    -- Pointer to memory for return value
* int *                -- Pointer to memory for return value
*
* RETURNS:
*
* Bytes read are returned in the given buffer memory.  The integer
* function return value is the number of bytes actually received (-1 = error).
* The ip address of the sender is returned in the memory passed in
* with 'from'.  The length of this ip address is passed back in 'fromlen'.
*
*/

int SK_recvfrom(int s, void *buffer, int buflen, int flags, struct sockaddr *from, int *fromlen)
{
    SKg_Config.DoAutoSpin();

    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->recvfrom(buffer, buflen, flags, from, fromlen) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_recvmsg
*
* DESCRIPTION:
*
* Receive a message on the given socket using a BSD Unix msghdr structure
* (which must contain a properly allocated iovec structure).
*
* PARAMETERS:
*
* int                -- The socket file descriptor
* struct msghdr *    -- The BSD msghdr structure for received message
* int                -- unused
*
* RETURNS:
*
* Bytes read are returned in the given iovec/msghdr memory.  The integer
* function return value is the number of bytes actually received or -1 on
* error, in which case a more specific error return is in the global variable
* errno (see appropriate socket type for details).
*
*/

int SK_recvmsg(int s, struct msghdr *msg, int flags)
{
    SKg_Config.DoAutoSpin();

    CSK_Socket *sock = SKg_SocketTable[s];

    if (sock) {
        CSK_Scatterer scatt((struct iovec *) msg->msg_iov, msg->msg_iovlen);

        if (scatt)
            return
                scatt.GetLength(
                    sock->recvfrom(
                        scatt.GetBuffer(),
                        scatt.GetBufferLength(),
                        flags,
                        msg->msg_name,
                        (int *) &msg->msg_namelen));
        else
            return SK_Error(ENOMEM);
    } else
        return -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_write
*
* DESCRIPTION:
*
* Write bytes to the given socket using a plain buffer.
*
* PARAMETERS:
*
* int                -- The socket file descriptor
* const char *        -- Pointer to buffer memory
* unsigned            -- Length of given buffer memory
*
* RETURNS:
*
* The integer function return value is the number of bytes actually written
* or -1 on error, in which case a more specific error return is in the global
* variable errno (see appropriate socket type for details).
*
*/

int SK_write(int s, const char *buffer, unsigned buflen)
{
    /* fflush() in the MPW stdio library doesn't take no for an answer.
        Our workaround is to treat a second subsequent ESHUTDOWN or EBADF as
        an invitation to lie by pretending the write worked.
    */

    int    len;

    SKg_Config.DoAutoSpin();

    CSK_Socket *sock = SKg_SocketTable[s];

    if (sock && (len = sock->write((char *) buffer, buflen)) != -1)
        return len;

    switch (errno) {
    case EINTR:
    case EWOULDBLOCK:
    case EINPROGRESS:
    case EALREADY:
        break;
    default:
        if (SKg_ErrorSock == s && SKg_ErrorType == errno) {
            if (++SKg_ErrorCount == SKg_ErrorMax) {
                SKg_ErrorSock = -1;

                return buflen;
            }
          } else {
            SKg_ErrorSock = s;
            SKg_ErrorType = errno;
            SKg_ErrorCount= 1;
        }
    }
     return -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_writev
*
* DESCRIPTION:
*
* Write bytes to the given socket using a BSD Unix iovec structure.
*
* PARAMETERS:
*
* int                    -- The socket file descriptor
* conststruct iovec *    -- Pointer to buffer memory
* int                    -- Number of bytes to write
*
* RETURNS:
*
* The integer function return value is the number of bytes actually written
* or -1 on error, in which case a more specific error return is in the global
* variable errno (see appropriate socket type for details).
*
*/

int SK_writev(int s, const struct iovec *iov, int count)
{
    SKg_Config.DoAutoSpin();

    CSK_Socket *sock = SKg_SocketTable[s];

    if (sock)    {
        CK_Gatherer    gath(iov, count);

        if (gath)
            return gath.GetLength(sock->write(gath.GetBuffer(), gath.GetBufferLength()));
        else
            return SK_Error(ENOMEM);
    } else
        return -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_send
*
* DESCRIPTION:
*
* Write bytes to the given socket using a plain buffer.  This is equivalent
* to SK_write(), except that it is used when bytes written conceptually make
* up a complete message [SK_write() is used to write bytes to an ongoing stream].
*
* PARAMETERS:
*
* int                    -- The socket file descriptor
* struct iovec *        -- Pointer to buffer memory
* int                    -- Length of given buffer
* int                    -- Unused
*
* RETURNS:
*
* The integer function return value is the number of bytes actually written
* or -1 on error, in which case a more specific error return is in the global
* variable errno (see appropriate socket type for details).
*
*/

int SK_send(int s, void *buffer, int buflen, int flags)
{
    SKg_Config.DoAutoSpin();

    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->sendto(buffer, buflen, flags, nil, 0) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_sendto
*
* DESCRIPTION:
*
* Write bytes to the given socket using a plain buffer and get internet
* address of the recipient.
*
* PARAMETERS:
*
* int                        -- The socket file descriptor
* struct iovec *            -- Pointer to buffer memory
* int                        -- Length of given buffer
* int                        -- Unused
* const struct sockaddr *    -- Pointer to memory for ip address return value
* int                        -- Length of memory for ip address return value
*
* RETURNS:
*
* The integer function return value is the number of bytes actually written
* or -1 on error, in which case a more specific error return is in the global
* variable errno (see appropriate socket type for details).  The internet
* address of the recipient is returned in memory passed in 'to', truncated
* if not enough memory was given.
*
*/

int SK_sendto(int s, void *buffer, int buflen, int flags, const struct sockaddr *to, int tolen)
{
    SKg_Config.DoAutoSpin();

    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->sendto(buffer, buflen, flags, (void *) to, tolen) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_sendmsg
*
* DESCRIPTION:
*
* Write a message to the given socket using a BSD Unix msghdr structure,
* which must contain a properly initialized iovec structure.
*
* PARAMETERS:
*
* int                    -- The socket file descriptor
* struct msghdr *        -- Pointer to BSD msghdr structure
* int                    -- Unused
*
* RETURNS:
*
* The integer function return value is the number of bytes actually written
* or -1 on error, in which case a more specific error return is in the global
* variable errno (see appropriate socket type for details).
*
*/

int SK_sendmsg(int s, const struct msghdr *msg,int flags)
{
    SKg_Config.DoAutoSpin();

    CSK_Socket *sock = SKg_SocketTable[s];

    if (sock)    {
        CK_Gatherer    gath((struct iovec *) msg->msg_iov, msg->msg_iovlen);

        if (gath)
            return
                gath.GetLength(
                    sock->sendto(
                        gath.GetBuffer(),
                        gath.GetBufferLength(),
                        flags,
                        msg->msg_name,
                        msg->msg_namelen));
        else
            return SK_Error(ENOMEM);
    } else
        return -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_select
*
* DESCRIPTION:
*
* Check the given read, write, and except file descriptor sets to see
* which items in those sets are ready for reading, ready for writing,
* or have an exceptional condition pending (respectively).  SK_select
* will replace each of these sets with subsets consisting of those
* descriptors that are ready for the requested operation.
*
* PARAMETERS:
*
* int                    -- Number of bits to be checked in each bit mask; 0 to width-1 are checked
*                           This is used to limit compute time by indicating where non-0 bits
*                           are located in the three fd_set parameters below.
* fd_set *                -- Pointer to BSD fd_set (modified for return value / nil = don't care)
* fd_set *                -- Pointer to BSD fd_set (modified for return value / nil = don't care)
* fd_set *                -- Pointer to BSD fd_set (modified for return value / nil = don't care)
* struct timeval *        -- BSD timeval structure giving time out value (nil = unlimited)
*
* RETURNS:
*
* int                    -- The total number of entries in all three return value sets or -1
*                           on error, in which case the global errno contains one of:
*
*     EBADF    One of the descriptor sets specified an invalid descriptor
*     EINTR    An interrupt was encountered before any of the selected events
*            occurred or before timeout limit
*
* NOTES:
*
* This routine is a bit over-commented because I am debugging some code
* that uses it.  Excuuuuse me!
*
*/

int SK_select(int width, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
{
    CSK_Socket *sock;
    long count;
    int s;
    long starttime, waittime;
    fd_set rd, wd, ed;
    Boolean    r,w,e;
    Boolean *canRead;
    Boolean *canWrite;
    Boolean *exception;

    // Initialize
    count = 0;
    FD_ZERO(&rd);
    FD_ZERO(&wd);
    FD_ZERO(&ed);

    // Compute time to wait in ticks (1/60th of a second)
    if (timeout) {
        waittime = timeout->tv_sec*60 + timeout->tv_usec/16666;
        starttime = TickCount();
    }

    // Check file descriptors for kosherness
    for (s = 0; s < width ; ++s)
        if (    (readfds && FD_ISSET(s,readfds))
            ||    (writefds && FD_ISSET(s,writefds))
            ||    (exceptfds && FD_ISSET(s,exceptfds))
        )
            if (!SKg_SocketTable[s])
                return SK_Error(EBADF);


    // Do pre-select
    for (s = 0; s < width ; ++s) {
        sock = SKg_SocketTable[s];
        if (sock != NULL) {
            r = readfds && FD_ISSET(s,readfds);
            w = writefds && FD_ISSET(s,writefds);
            e = exceptfds && FD_ISSET(s,exceptfds);

            if (r || w || e)
                 sock->pre_select(r, w, e);
         }
     }

    // Compute return sets using first "width" file descriptors in socket table
    // Outer do loop will execute until some entries are placed into some set
    // or until timeout is reached
    do {
        // Look through socket table for sockets ready for requested operations
        for (s = 0; s < width ; ++s)  {
            // Get socket
            sock = SKg_SocketTable[s];
            if (sock != NULL) {
                // Init temporary flags
                r = false;
                w = false;
                e = false;

                // Set temporary return values to <> nil iff the caller was
                // interested in these operations for this specific file descriptor
                canRead = (readfds && FD_ISSET(s,readfds)) ? &r : nil;
                canWrite = (writefds && FD_ISSET(s,writefds)) ? &w : nil;
                exception = (exceptfds && FD_ISSET(s,exceptfds)) ? &e : nil;

                // If user was interested in any operation for this socket,
                // then call the socket to check status on each that was
                // of interest
                if (canRead || canWrite || exception) {
                    // Call socket and increment count by number of requested
                    // operations that this socket is ready for
                    count += sock->select(canRead, canWrite, exception);

                    // For each operation returning TRUE, add this socket
                    // to the appropriate return value bit vector set
                    if (r)
                        FD_SET(s,&rd);
                    if (w)
                        FD_SET(s,&wd);
                    if (e)
                        FD_SET(s,&ed);
                }
            }
        }

        // Kill time & give up one time slice; if user hit cancel, then
        // errno is set = EINTR and select returns immediately with
        // a -1 return value
        SPIN(false, SKk_SELECT, 0);

    }  while(!count &&(!timeout || TickCount() - starttime < waittime));

    // Do post-select
     for (s = 0; s < width ; ++s) {
         sock = SKg_SocketTable[s];
        if (sock != NULL) {
            r = readfds && FD_ISSET(s,readfds);
            w = writefds && FD_ISSET(s,writefds);
            e = exceptfds && FD_ISSET(s,exceptfds);

             if (r || w || e)
                 sock->post_select(r, w, e);
         }
     }


    // Set return file descriptor sets
    if (readfds)
        *readfds = rd;
    if (writefds)
        *writefds = wd;
    if (exceptfds)
        *exceptfds = ed;

    // Return number of entries total in all returned sets
    return count;
}


/****************************************************************************
* FUNCTION:
*
* SK_getsockname
*
* DESCRIPTION:
*
* Get name of given socket
*
* PARAMETERS:
*
* int                    -- The socket file descriptor
* struct sockaddr *        -- Pointer to memory for name return value
* int *                    -- Pointer to memory for return value (initialized
*                           to space available in name return buffer)
*
* RETURNS:
*
* The integer function return value -1 on error, in which case a more
* specific error return is in the global variable errno (see appropriate
* socket type for details).
*
*/

int SK_getsockname(int s, struct sockaddr *name, int *namelen)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->getsockname(name, namelen) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_getpeername
*
* DESCRIPTION:
*
* Get name of the remote peer connected to given socket
*
* PARAMETERS:
*
* int                    -- The socket file descriptor
* struct sockaddr *        -- Pointer to memory for return value
* int *                    -- Pointer to memory for return value (initialized
*                           to space available in name return buffer)
*
* RETURNS:
*
* The integer function return value -1 on error, in which case a more
* specific error return is in the global variable errno (see appropriate
* socket type for details).
*
*/

int SK_getpeername(int s, struct sockaddr *name, int *namelen)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->getpeername(name, namelen) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_shutdown
*
* DESCRIPTION:
*
* Shut down part or all of a connection on a given socket
*
* PARAMETERS:
*
* int            -- The socket file descriptor
* int            -- How to shut down : If 0, then further receives
*                   will be disallowed.  If 1,  then further sends will
*                   be disallowed.  If 2, then further sends and receives
*                   will be disallowed.
*
* RETURNS:
*
* The integer function return value -1 on error or 0 on success.
*
*/

int SK_shutdown(int s, int how)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->shutdown(how) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_fcntl
*
* DESCRIPTION:
*
* Operate on (or control) the given socket
*
* PARAMETERS:
*
* int            -- The socket file descriptor
* int            -- Command - see specific socket types for details
* int            -- Argument - see specific socket types for details
*
* RETURNS:
*
* The integer function return value -1 on error or 0 on success.
*
*/

int SK_fcntl(int s, unsigned int cmd, int arg)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    if (sock)
        return (cmd == F_DUPFD) ? SKg_SocketTable.Install(sock, arg) : sock->fcntl(cmd, arg);
    else
        return -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_dup
*
* DESCRIPTION:
*
* ???
*
* PARAMETERS:
*
* int            -- The socket file descriptor
*
* RETURNS:
*
* ???
*
*/

int SK_dup(int s)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? SKg_SocketTable.Install(sock) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_dup2
*
* DESCRIPTION:
*
* ???
*
* PARAMETERS:
*
* int            -- The socket file descriptor
* int            -- ???
*
* RETURNS:
*
* ???
*
*/

int SK_dup2(int s, int s1)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    if (!sock)
        return -1;

    if (SKg_SocketTable[s1])
        SKg_SocketTable.Remove(s1);

    return SKg_SocketTable.Install(sock, s1);
}


/****************************************************************************
* FUNCTION:
*
* SK_ioctl
*
* DESCRIPTION:
*
* ???
*
* PARAMETERS:
*
* int            -- The socket file descriptor
* int            -- ???
* char *        -- ???
*
* RETURNS:
*
* ???
*
*/

int SK_ioctl(int s, unsigned int request, char *argp)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->ioctl(request, argp) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_getsockopt
*
* DESCRIPTION:
*
* ???
*
* PARAMETERS:
*
* int            -- The socket file descriptor
* int            -- ???
* int            -- ???
* char *        -- ???
* int *            -- ???
*
* RETURNS:
*
* ???
*
*/

int SK_getsockopt(int s, int level, int optname, void *optval, int * optlen)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->getsockopt(level, optname, optval, optlen) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_setsockopt
*
* DESCRIPTION:
*
* ???
*
* PARAMETERS:
*
* int            -- The socket file descriptor
* int            -- ???
* int            -- ???
* char *        -- ???
* int             -- ???
*
* RETURNS:
*
* ???
*
*/

int SK_setsockopt(int s, int level, int optname, void *optval, int optlen)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->setsockopt(level, optname, optval, optlen) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_fstat
*
* DESCRIPTION:
*
* ???
*
* PARAMETERS:
*
* int                -- The socket file descriptor
* struct stat *        -- ???
*
* RETURNS:
*
* ???
*
*/

int SK_fstat(int s, struct stat * buf)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->fstat(buf) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_lseek
*
* DESCRIPTION:
*
* ???
*
* PARAMETERS:
*
* int                -- The socket file descriptor
* long                -- ???
* int                -- ???
*
* RETURNS:
*
* ???
*
*/

long SK_lseek(int s, long offset, int whence)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->lseek(offset, whence) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_ftruncate
*
* DESCRIPTION:
*
* ???
*
* PARAMETERS:
*
* int                -- The socket file descriptor
* long              -- ???
*
* RETURNS:
*
* ???
*
*/

int SK_ftruncate(int s, long offset)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->ftruncate(offset) : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_isatty
*
* DESCRIPTION:
*
* Check whether the given socket is a tty (real or virtual ascii terminal)
*
* PARAMETERS:
*
* int                -- The socket file descriptor
*
* RETURNS:
*
* TRUE (<> 0) when the socket is a tty, or FALSE (0) when it is not.
*
*/

int SK_isatty(int s)
{
    CSK_Socket *sock = SKg_SocketTable[s];

    return sock ? sock->isatty() : -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_Error
*
* DESCRIPTION:
*
* Set the global errno to the given value and return -1
*
* PARAMETERS:
*
* int                -- The error value
*
* RETURNS:
*
* Always -1.
*
*/

int SK_Error(int err)
{
    errno =    err;

    return -1;
}


/****************************************************************************
* FUNCTION:
*
* SK_Error_nil
*
* DESCRIPTION:
*
* Set the global errno to the given value and return nil
*
* PARAMETERS:
*
* int                -- The error value
*
* RETURNS:
*
* Always nil.
*
*/

void *SK_Error_nil(int err)
{
    errno =    err;

    return nil;
}


/****************************************************************************
* FUNCTION:
*
* SK_SetSpin
*
* DESCRIPTION:
*
* Set the spin routine to use during idle times waiting on sockets
*
* PARAMETERS:
*
* SKt_SpinFn        -- The spin function to use
*
*/

void SK_SetSpin(SKt_SpinFn routine)
{
    SKg_SpinRoutine = routine;
}


/****************************************************************************
* FUNCTION:
*
* SK_GetSpin
*
* DESCRIPTION:
*
* Get the spin routine used during idle times waiting on sockets
*
* RETURNS:
*
* SKt_SpinFn        -- The spin function to use
*
*/

SKt_SpinFn SK_GetSpin()
{
    return SKg_SpinRoutine;
}


/****************************************************************************
* FUNCTION:
*
* SK_SetEvents
*
* DESCRIPTION:
*
* Set the event dispatch vector to use with the default SK spin routine
*
* PARAMETERS:
*
* SKt_EvtHandler *        -- The event handler call vector
*
* RETURNS:
*
* Error value (0 = success; else failure).
*/

int SK_SetEvents(SKt_EvtHandler *table)
{
    short    evt;

    SKg_EventHandler = table;
    SKg_EvtMask = 0;

    /* Set up event mask according to values in event handler table */
    for (evt = 0; evt<16; ++evt)
        if (SKg_EventHandler[evt])
            SKg_EvtMask    |=    1 << evt;

    return 0;
}


/****************************************************************************
* FUNCTION:
*
* SK_GetEvents
*
* DESCRIPTION:
*
* Get the event dispatch vector used with the default SK spin routine
*
* RETURNS:
*
* SKt_EvtHandler *    -- Pointer to the first item in the event handler call vector
*/

SKt_EvtHandler *SK_GetEvents(void)
{
    return SKg_EventHandler;
}


/**************************************************************************/
/* CSK_Configuration members */

/* xFirstTime static member variable for initialization */
Boolean CSK_Configuration::xFirstTime = false;

/* Callback for handling unsupported apple events */
pascal OSErr
SK_UnsupportedAEVT(AppleEvent* /*messagein*/, AppleEvent* /*reply*/, long /*refIn*/)
{
    return errAEEventNotHandled;
}

/*************************************************************************** *
* FUNCTION:
*
* CSK_Configuration::CSK_Configuration()
*
* DESCRIPTION:
*
* Constructor for CSK_Configuration class
*
*/

CSK_Configuration::CSK_Configuration()
{
    const long    stdEvt[] = {
        kAEOpenApplication,
        kAEOpenDocuments,
        kAEQuitApplication,
        kAEPrintDocuments
    };

    fTCPDaemon=    SKk_TCPDaemon;
    fUDPDaemon=    SKk_UDPDaemon;

    fAutoSpin = SKk_AutoSpin;    // Do automatic spin on read/write
    fVersion = SKk_Version;

    if (!xFirstTime) {
        xFirstTime = true;

        if (IsDaemon())
            for (int i = 0; i < sizeof(stdEvt); i++)
                AEInstallEventHandler(
                    kCoreEventClass,
                    stdEvt[i],
                    AEEventHandlerProcPtr(SK_UnsupportedAEVT),
                    0,
                    false);
    }
}

/*************************************************************************** *
* FUNCTION:
*
* CSK_Configuration::DoAutoSpin()
*
* DESCRIPTION:
*
* Execute the SK "spin" function
*
*/

inline void CSK_Configuration::DoAutoSpin() const
{
    if (fAutoSpin)
        SAFESPIN(0, SKk_AUTO_SPIN, fAutoSpin);
}

/*************************************************************************** *
* FUNCTION:
*
* CSK_Configuration::IsDaemon()
*
* DESCRIPTION:
*
* Return TRUE if this application is a daemon (and not a regular stand-alone)
*
*/

Boolean CSK_Configuration::IsDaemon() const
{
    return fTCPDaemon || fUDPDaemon;
}


/**************************************************************************/
/**************************************************************************/
/* CSK_SocketDomain members */

/* Static array of socket domains */
CSK_SocketDomain *CSK_SocketDomain::xDomains[SKk_MAX_DOMAIN];


/****************************************************************************
* FUNCTION:
*
* CSK_SocketDomain::CSK_SocketDomain
*
* DESCRIPTION:
*
* Constructor for this class
*
* PARAMETERS:
*
* int domain        -- the socket identifier (= index into xDomains static array
*                       at which this socket is to be placed)
*
*/

CSK_SocketDomain::CSK_SocketDomain(int domain)
{
    ASSERT(xDomains[domain] == NULL);
    xDomains[domain] = this;
}

/****************************************************************************
* FUNCTION:
*
* CSK_SocketDomain::~CSK_SocketDomain
*
* DESCRIPTION:
*
* Destructor for this class
*
*/

CSK_SocketDomain::~CSK_SocketDomain()
{
}

/****************************************************************************
* FUNCTION:
*
* CSK_SocketDomain::Domain
*
* DESCRIPTION:
*
* Return the socket corresponding with a given identifier for this domain
*
* PARAMETERS:
*
* int                 -- the socket identifier (= index into xDomains static array)
*
* RETURNS:
*
* CK_SocketDomain    -- a pointer to the requested socket (or nil if none found)
*
*/

CSK_SocketDomain *CSK_SocketDomain::Domain(int domain)
{
    ASSERT(domain >= 0 && domain < SKk_MAX_DOMAIN);
    if (xDomains[domain] == NULL)
        return nil;
    else
        return xDomains[domain];
}

/*************************************************************************** *
* FUNCTION:
*
* CSK_SocketDomain::open
*
* DESCRIPTION:
*
* Default implementation of open() -- just returns an error
*
* PARAMETERS:
*
* const char*        -- unused
* int                -- unused
*
* RETURNS:
*
*
* NOTES:
*
*
*/

CSK_Socket * CSK_SocketDomain::open(const char *, int)
{
    UNIMPLEMENTED;
    return(NULL);
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_SocketDomain::open
*
* DESCRIPTION:
*
* Default implementation of socket() -- just returns an error
*
* PARAMETERS:
*
* int                -- unused
* short                -- unused
*
* RETURNS:
*
*
* NOTES:
*
*
*/

CSK_Socket * CSK_SocketDomain::socket(int, short)
{
    UNIMPLEMENTED;
    return(NULL);
}


/**************************************************************************/
/**************************************************************************/
/* CLurkSocket members */

class CLurkSocket : public CSK_Socket {
public:
    CLurkSocket(int descr);
};


/*************************************************************************** *
* FUNCTION:
*
* CLurkSocket::CLurkSocket
*
* DESCRIPTION:
*
* Constructor for this class
*
* PARAMETERS:
*
* int                 -- lurking socket's file descriptor
*
*/

CLurkSocket::CLurkSocket(int descr) : CSK_Socket()
{
    fLurking = true;
    fLurkDescr = char(descr);
}


/**************************************************************************/
/**************************************************************************/
/* CSK_SocketTable members */

/*************************************************************************** *
* FUNCTION:
*
* CSK_SocketTable::CSK_SocketTable
*
* DESCRIPTION:
*
* Constructor for this class
*
*/

CSK_SocketTable::CSK_SocketTable()
{
    // Allocate first 4 "lurking" sockets for TCP and UDP daemon programs
    // (that is, any that are not a full stand-alone program)
    for (int i = 0; (i < 3) & !STANDALONE; i++)
        if (SKg_Config.IsDaemon()) {
            fSockets[i]    =    new CLurkSocket(i);
        } else {
// -- NOT NEEDED SINCE WE DEAL ONLY WITH TCP/UDP.  I think. -------
//          (want to avoid including FileSockets stuff!)
//
//            fSockets[i]    = FileSockets.stdopen(i);
//
//            ++fSockets[i]->fRefCount;
// ----------------------------------------------------------------
            UNIMPLEMENTED;
        }
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_SocketTable::~CSK_SocketTable
*
* DESCRIPTION:
*
* Destructor for this class
*
*/

/*
FILE *_lastbuf = _iob + _NFILE;
*/

CSK_SocketTable::~CSK_SocketTable()
{
    int i;

    // Flush and vclose stdio files (necessary to flush buffers)
    // This implementation is not nice, but who cares ?
    // In case you wonder, _iob is defined in <stdio.h>
// -- NOT NEEDED SINCE WE DEAL ONLY WITH TCP/UDP.  I think. -------
//    for (i = 0; _iob+i<_lastbuf; i++)
//        fflush(_iob+i);
//
//    for (i = 0; _iob+i<_lastbuf; i++)
//        fclose(_iob+i);
// ----------------------------------------------------------------

    // Close all sockets
    for (i = 0; i<SKk_MaxFD; ++i)
        if (fSockets[i])
            SK_close(i);
}


/*************************************************************************** *
* FUNCTION:
*
* int CSK_SocketTable::Install
*
* DESCRIPTION:
*
* Install a socket into this socket table
*
* PARAMETERS:
*
* CSK_Socket *                -- Pointer to socket to install
* int                        -- Minimum file descriptor to use for socket
*
* RETURNS:
*
* File descriptor assigned to given socket
*
*/

int CSK_SocketTable::Install(CSK_Socket * sock, int start)
{
    short fd;

    ASSERT(start >= 0 && start < SKk_MaxFD);

    for (fd=start; fd<SKk_MaxFD; ++fd)
        if (!fSockets[fd])    {
            fSockets[fd] = sock;
            ++sock->fRefCount;
            return fd;
        }

    return SK_Error(EMFILE);
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_SocketTable::Possess
*
* DESCRIPTION:
*
* Replace a lurking socket of given descriptor with the given socket
*
* PARAMETERS:
*
* int                -- File descriptor for socket
* CSK_Socket *        -- Pointer to socket
*
*/

void CSK_SocketTable::Possess(int descr, CSK_Socket * sock)
{
    int i;

    for (i = 0; i<SKk_MaxFD; ++i)
        if (fSockets[i]->fLurking && fSockets[i]->fLurkDescr == descr) {
            SK_close(i);
            fSockets[i] = sock;
            if (sock != NULL)
                ++sock->fRefCount;
        }
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_SocketTable::Remove
*
* DESCRIPTION:
*
* Remove the socket with given file descriptor from this socket table
*
* PARAMETERS:
*
* int            -- File descriptor for socket to remove
*
* RETURNS:
*
* int            -- Error or 0 if no error
*
* NOTES:
*
*
*/

int CSK_SocketTable::Remove(int fd)
{
    CSK_Socket *    sock;

    if (fd<0 || fd >= SKk_MaxFD || !(sock = fSockets[fd]))
        return SK_Error(EBADF);

    fSockets[fd]     =    nil;

    if (!--sock->fRefCount)
        delete sock;

    return 0;
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_SocketTable::operator[]
*
* DESCRIPTION:
*
* Index [] operator for socket tables.  Returns the socket with given file
* descriptor or nil if not found.
*
* PARAMETERS:
*
* int                -- The file descriptor of socket to locate in table
*
* RETURNS:
*
* CSK_Socket *        -- Pointer to socket with given descriptor (or nil if not found)
*
* NOTES:
*
* Note that this function will wait, calling the SK idle "spin" routine
* if the given socket is lurking.  When the socket is no longer lurking, the
* pointer to the socket will be returned.
*
*/

CSK_Socket * CSK_SocketTable::operator[](int fd)
{
    CSK_Socket * sock;

    restart:
    if (fd<0 || fd >= SKk_MaxFD || !(sock = fSockets[fd]))    {
        SK_Error(EBADF);
        return nil;
    } else if (sock->fLurking) {
        SPINP(fSockets[fd]->fLurking, SKk_MISC, 0);
        goto restart;
    } else
        return sock;
}


/**************************************************************************/
/**************************************************************************/
/* CSK_Feature members */


/*************************************************************************** *
* FUNCTION:
*
* CSK_Feature::CSK_Feature
*
* DESCRIPTION:
*
* Constructor for this class
*
* PARAMETERS:
*
* short             -- Macintosh trap number
* TrapType            -- Type of trap
*
*/

CSK_Feature::CSK_Feature(short trapNum, TrapType tTyp)
{
    fGood = (NGetTrapAddress(trapNum, tTyp) != NGetTrapAddress(_Unimplemented, ToolTrap));
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_Feature::CSK_Feature
*
* DESCRIPTION:
*
* Constructor for this class
*
* PARAMETERS:
*
* OSType             --
* long                --
*
*/

CSK_Feature::CSK_Feature(OSType type, long value)
{
    long attr;

    fGood = (!Gestalt(type, &attr) && (attr >= value));
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_Feature::CSK_Feature
*
* DESCRIPTION:
*
* Constructor for this class
*
* PARAMETERS:
*
* OSType             --
* long                --
* long                --
*
*/

CSK_Feature::CSK_Feature(OSType type, long mask, long value)
{
    long attr;

    fGood = (!Gestalt(type, &attr) && ((attr & mask) == value));
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_Feature::CSK_Feature
*
* DESCRIPTION:
*
* Constructor for this class
*
* PARAMETERS:
*
* const CSK_Feature &         --
* SKt_OSErrInitializer        --
*
*/

CSK_Feature::CSK_Feature(const CSK_Feature & precondition, SKt_OSErrInitializer init)
{
    fGood = (precondition && !init());
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_Feature::CSK_Feature
*
* DESCRIPTION:
*
* Constructor for this class
*
* PARAMETERS:
*
* SKt_OSErrInitializer        --
*
*/

CSK_Feature::CSK_Feature(SKt_OSErrInitializer init)
{
    fGood = !init();
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_Feature::CSK_Feature
*
* DESCRIPTION:
*
* Constructor for this class
*
* PARAMETERS:
*
* const CSK_Feature &         --
* SKt_VoidInitializer        --
*
*/

CSK_Feature::CSK_Feature(const CSK_Feature & precondition, SKt_VoidInitializer init)
{
    if (precondition)    {
        fGood = true;
        init();
    } else
        fGood = false;
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_Feature::CSK_Feature
*
* DESCRIPTION:
*
* Constructor for this class
*
* PARAMETERS:
*
* SKt_VoidInitializer        --
*
*/

CSK_Feature::CSK_Feature(SKt_VoidInitializer init)
{
    fGood = true;
    init();
}


/*************************************************************************** *
* FUNCTION:
*
* CSK_Feature::CSK_Feature
*
* DESCRIPTION:
*
* Constructor for this class
*
* PARAMETERS:
*
* const CSK_Feature &        --
* const CSK_Feature &        --
*
*/

CSK_Feature::CSK_Feature(const CSK_Feature & cond1, const CSK_Feature & cond2)
{
    fGood = (cond1 && cond2);
}


/**************************************************************************/
/**************************************************************************/
/* Default spin function & associated utilities */

/* Borrowed from tech note 263 */

/* Constants used with default spin function */

#define kMaskModifiers      0xFE00         // we need the modifiers without the
                                           // command key for KeyTrans
#define kMaskVirtualKey     0x0000FF00     // get virtual key from event message
                                           // for KeyTrans
#define kUpKeyMask          0x0080
#define kShiftWord          8              // we shift the virtual key to mask it
                                           // into the keyCode for KeyTrans
#define kMaskASCII1         0x00FF0000     // get the key out of the ASCII1 byte
#define kMaskASCII2         0x000000FF     // get the key out of the ASCII2 byte
#define kPeriod             0x2E           // ascii for a period


/*************************************************************************** *
* FUNCTION:
*
* SK_CmdPeriod
*
* DESCRIPTION:
*
* Check the given event record to see if it is a command-period keyboard event.
*
* PARAMETERS:
*
* EventRecord *            -- The Macintosh event record to check
*
* RETURNS:
*
* Boolean                -- TRUE if event record is command-period
*
* NOTES:
*
* Should replace this later to use Jonathan's GUI toolkit instead of being
* Mac-specific
*
*/

static Boolean SK_CmdPeriod(EventRecord *theEvent)
{
      Boolean fTimeToQuit;
      short keyCode;
      long virtualKey, keyInfo, lowChar, highChar, state, keyCId;
      Handle hKCHR;
    Ptr KCHRPtr;

    fTimeToQuit = false;

    if (((*theEvent).what == keyDown) || ((*theEvent).what == autoKey)) {

        // see if the command key is down.  If it is, find out the ASCII
        // equivalent for the accompanying key.

        if ((*theEvent).modifiers & cmdKey ) {

            virtualKey = ((*theEvent).message & kMaskVirtualKey) >> kShiftWord;
            // And out the command key and Or in the virtualKey
            keyCode    = short(((*theEvent).modifiers & kMaskModifiers) | virtualKey);
            state      = 0;

            hKCHR = nil;  /* set this to nil before starting */
             KCHRPtr = (Ptr)GetEnvirons(smKCHRCache);

            if ( !KCHRPtr ) {
                keyCId = GetScript(short(GetEnvirons(smKeyScript)), smScriptKeys);

                hKCHR   = GetResource('KCHR',short(keyCId));
                KCHRPtr = *hKCHR;
            }

            if (KCHRPtr) {
                keyInfo = KeyTrans(KCHRPtr, keyCode, &state);
                if (hKCHR)
                    ReleaseResource(hKCHR);
            } else
                keyInfo = (*theEvent).message;

            lowChar =  keyInfo &  kMaskASCII2;
            highChar = (keyInfo & kMaskASCII1) >> 16;
            if (lowChar == kPeriod || highChar == kPeriod)
                fTimeToQuit = true;

        }  // end the command key is down
    }  // end key down event

    return( fTimeToQuit );
}


/*************************************************************************** *
* FUNCTION:
*
* SK_DefaultSpinRoutine
*
* DESCRIPTION:
*
* The default "spin" routine for SK.  This is used to provide limited multi-
* threading during waits for communications ports, etc.  The routine gives
* up time slices to the system and other applications and also processes
* basic GUI events to allow cancel (command-.) and switching of application
* into background while it is processing.
*
* This spin routine will call event handlers in the SKg_EventHandler[]
* array when they are present for specific types of events (the index in
* the array is the Macintosh event type used in WaitNextEvent()).  If
* no handler is included for kHighLevelEvent events, then AEProcessAppleEvent()
* is called directly.
*
* You should use SK_SetEvents() to set the event handler array when SK
* is initialized.
*
* PARAMETERS:
*
* SKt_SpinMsg            --
* long                    --
*
* RETURNS:
*
* int                    -- error return (0 = no error)
*
* NOTES:
*
* Could replace this later to use DSG's GUI portability layer instead of being
* Mac-specific.
*
* Should rewrite this to check what parts of the toolkit were initialized
* and bail out gracefully if some vital initialization is missing.
*
*/

/*
* This MUST be extern "C" so that dispatching works properly (at least
* under THINK C++ 6.0 there is a bug (?) with converting between regular
* C and C++ functions in non-debug code)
*/
extern "C" {

/* Local utility function */
Boolean SK_Interrupt()
{
    EvQElPtr eventQ;

    for (eventQ = (EvQElPtr) GetEvQHdr()->qHead; eventQ; )
         if (SK_CmdPeriod((EventRecord *) &eventQ->evtQWhat))
            return true;
        else
            eventQ = (EvQElPtr)eventQ->qLink;

    return false;
}

int SK_DefaultSpinRoutine(SKt_SpinMsg msg, long arg)
{
    static Boolean inForeground = true;
    static Boolean lastEventCheck = TickCount();
    WindowPtr win;
    EventRecord ev;

//  Commented out because we lack SpinCursor, which was only defined in MPW
//
//    if (inForeground)
//        SpinCursor(msg == SKk_AUTO_SPIN ? short(arg) : 1);

    if (!inForeground || STANDALONE)    {
        if (SK_Interrupt())
            goto interrupt;

        if (SKg_WNE)    {
            if (WaitNextEvent(osMask|highLevelEventMask|mDownMask|SKg_EvtMask, &ev, 1, nil)) {
                   // Process the event, if any
                switch (ev.what) {
                    case mouseDown:
                        if (!SKg_EventHandler || !SKg_EventHandler[mouseDown])
                            if (FindWindow(ev.where, &win) == inSysWindow)
                                SystemClick(&ev, win);

                        break;
                    case osEvt:
                        if (ev.message & 1)
                            inForeground    =    true;
                        else
                            inForeground    =    false;
                        break;
                    case kHighLevelEvent:
                        if (!SKg_EventHandler || !SKg_EventHandler[kHighLevelEvent])
                            if (SKg_AppleEvents)    // Actually pretty likely, if we get HL Events
                                if (AEProcessAppleEvent(&ev))
                                    return -1;
                        break;
                    default:
                        break;
                    }
                if ((ev.what >= 0) && (ev.what < SKk_MaxEvents) && (SKg_EventHandler != NULL) &&
                       (SKg_EventHandler[ev.what] != NULL))
                    SKg_EventHandler[ev.what](&ev);
                }

        } else {
            long     endTicks;

            SystemTask();
            GetNextEvent(SKg_EvtMask, &ev);

            if ((ev.what >= 0) && (ev.what < SKk_MaxEvents) && (SKg_EventHandler != NULL) &&
                (SKg_EventHandler[ev.what] != NULL))
                SKg_EventHandler[ev.what](&ev);

            Delay(1, &endTicks);   /* Probably not a good way to do this! */
        }
    }

    return 0;


    /********/
    interrupt:

    FlushEvents(-1, 0);

    return -1;
    }

}


/* end of SK_Dispatch.cc */